package com.jt.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.ItemCatMapper;
import com.jt.pojo.ItemCat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.*;

@Service
public class ItemCatServiceImpl implements ItemCatService {
    @Autowired
    private ItemCatMapper itemCatMapper;


    /**
     * 1.判断map集合中是否存在key
     * 2.如果key 不存在   准备一个新List集合 将自己作为第一个元素添加
     * 3.如果key 存在   获取list集合 将自己追加
     * @return
     */
    public Map<Integer,List<ItemCat>> getMap() {
        Map<Integer, List<ItemCat>> map = new HashMap<>();
        //1.查询所有数据
        List<ItemCat> list = itemCatMapper.selectList(null);
        for (ItemCat itemCat : list) {
            int key = itemCat.getParentId();
            if (map.containsKey(key)) {// 有数据 将自己追加
                map.get(key).add(itemCat);
            } else {//没有数据 准备一个新list集合  添加数据
                List<ItemCat> childrenList = new ArrayList<>();
                childrenList.add(itemCat);
                map.put(key, childrenList);
            }
        }
        return map;
    }
    /**
     * 只查询一级菜单  parent_id = 0 或者level = 1
     * 查询二级菜单信息 parent_id = 一级ID
     * 查询三级菜单信息 parent_id = 二级ID
     * @param level
     * @return
     */
    @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long startTime = System.currentTimeMillis();
        //1.获取数据信息
        Map<Integer,List<ItemCat>> map = getMap();
        if (level == 1){//只获取一级菜单数据
            return map.get(0);
        }
        if (level == 2){//获取1-2级数据
            return getTwoList(map);
        }
        //获取 1-2-3数据
        List<ItemCat> list = getThreeList(map);
        long endTime = System.currentTimeMillis();
        System.out.println("耗时："+(endTime - startTime));
        return list;
    }


//    @Override
//    public List<ItemCat> findItemCatList(Integer level) {
//        long startTime = System.currentTimeMillis();
//        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
//        queryWrapper.eq("parent_id", 0);
//        List<ItemCat> oneList = itemCatMapper.selectList(queryWrapper);
//        for (ItemCat oneItemCat : oneList) {
//            //获取一级对象的ID
//            int oneId = oneItemCat.getId();
//            //清空多页的数据
//            queryWrapper.clear();
//            //查询二级数据
//            queryWrapper.eq("parent_id", oneId);
//            List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);
//            //将二级数据封装到一级对象中
//            oneItemCat.setChildren(twoList);
//            for (ItemCat twoItemCat : twoList) {
//                //获取二级对象的ID
//                int twoId = twoItemCat.getId();
//                //情况多余的数据
//                queryWrapper.clear();
//                //查询三级数据
//                queryWrapper.eq("parent_id", twoId);
//                List<ItemCat> threeList = itemCatMapper.selectList(queryWrapper);
//                //将三级数据封装到二级数据中
//                twoItemCat.setChildren(threeList);
//            }
//        }
//        long endTime = System.currentTimeMillis();
//        System.out.println("耗时："+(endTime - startTime)+"毫秒");
//        return oneList;
//    }

    private List<ItemCat> getThreeList(Map<Integer, List<ItemCat>> map) {
        //1.获取一级和二级数据
        List<ItemCat> oneList = getTwoList(map);
        for (ItemCat oneItemCat:oneList){
            List<ItemCat> twoList = oneItemCat.getChildren();
            if (twoList == null){
                //说明该一级下没有二级数据 所以跳过本次循环进入下次循环
                continue;
            }
            for (ItemCat twoItemCat:twoList){
                //查询三级数据 使用二级Id
                int key = twoItemCat.getId();
                List<ItemCat> threeList = map.get(key);
                twoItemCat.setChildren(threeList);
            }
        }
        return oneList;
    }


    private List<ItemCat> getTwoList(Map<Integer, List<ItemCat>> map) {
        //获取一级数据
        List<ItemCat> oneList = map.get(0);
        for (ItemCat oneItemCat:oneList){
            int key = oneItemCat.getId(); //id map中的key
            List<ItemCat> twoList = map.get(key);
            //将二级数据封装到一级中
            oneItemCat.setChildren(twoList);
        }
        return oneList;
    }

    //
    @Override
    @Transactional  //事务注解
    public void updateStatus(ItemCat itemCat) {
        itemCat.setId(itemCat.getId()).setStatus(itemCat.getStatus());
        itemCatMapper.updateById(itemCat);
    }

    @Override
    @Transactional  //事务注解
    public void saveItemCat(ItemCat itemCat) {
        itemCat.setStatus(true);
                /*.setCreated(new Date())
                .setUpdated(itemCat.getCreated());*/
        itemCatMapper.insert(itemCat);
    }

    @Override
    @Transactional  //事务注解
    public void updateItemCat(ItemCat itemCat) {
        //itemCat.setId(itemCat.getId()).setName(itemCat.getName()).setUpdated(new Date());
        itemCatMapper.updateById(itemCat);
    }

    /**
     * 删除的思路：
     *      1.判断是否为3级  如果是 直接删除
     *      2.判断是否为2级  如果是 先删除三级 再删除二级
     *      3.如果是1级,先查询2级,在删除3级/2级/1级
     * @param itemCat
     */
    @Override
    @Transactional  //事务注解
    public void deleteItemCat(ItemCat itemCat) {
        if(itemCat.getLevel() == 3){
            itemCatMapper.deleteById(itemCat.getId());
            return;
        }
        if(itemCat.getLevel() ==2){
            int twoId = itemCat.getId();
            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id",twoId);
            //删除的是三级数据
            itemCatMapper.delete(queryWrapper);
            itemCatMapper.deleteById(twoId);
            return;
        }
        //执行到这里 只剩下一级菜单
        //1.应该先查询二级
        int oneId = itemCat.getId();
        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id", oneId);
        List<Object> twoIdList = itemCatMapper.selectObjs(queryWrapper);
        if (twoIdList.size() == 0){
            //如果没有二级数据 则直接删除一级信息
            itemCatMapper.deleteById(oneId);
        }else {
            //表示有二级,可以删除三级
            //sql : delete from item_cat where parent_id in 二级ID  or id in(xx,xx,oneId)
            queryWrapper.clear();
            queryWrapper.in("parent_id",twoIdList)
                    .or()
                    .in("id",twoIdList)
                    .or()
                    .eq("id" ,oneId);
            itemCatMapper.delete(queryWrapper);
        }
    }
}